{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# cnn-mnist\n",
    "使用tensorflow，构造并训练一个神经网络，在测试机上达到超过98%的准确率。 \n",
    "作业详情：https://gitee.com/ai100/quiz-w7-1-cnn-mnist "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'channels_last'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"A very simple MNIST classifier.\n",
    "See extensive documentation at\n",
    "https://www.tensorflow.org/get_started/mnist/beginners\n",
    "\"\"\"\n",
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "\n",
    "import argparse\n",
    "import sys\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "\n",
    "from keras.layers.core import Dense, Flatten, Dropout\n",
    "from keras.layers.convolutional import Conv2D\n",
    "from keras.layers.pooling import MaxPooling2D\n",
    "from keras import initializers\n",
    "from keras.layers import advanced_activations\n",
    "\n",
    "from keras import backend as K\n",
    "\n",
    "K.image_data_format() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们在这里调用系统提供的Mnist数据函数为我们读入数据，如果没有下载的话则进行下载。\n",
    "\n",
    "<font color=#ff0000>**这里将data_dir改为适合你的运行环境的目录**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-698ada706af1>:3: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\t10k-images-idx3-ubyte.gz\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n"
     ]
    }
   ],
   "source": [
    "# Import data\n",
    "data_dir = '/tmp/tensorflow/mnist/input_data'\n",
    "mnist = input_data.read_data_sets(data_dir, one_hot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义输入输出\n",
    "x = tf.placeholder(tf.float32, [None, 784])\n",
    "y_ = tf.placeholder(tf.float32, [None, 10])\n",
    "# 学习速率\n",
    "learning_rate = tf.placeholder(tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('reshape'):\n",
    "  x_image = tf.reshape(x, [-1, 28, 28, 1])\n",
    "\n",
    "\n",
    "# 二维卷积层，即对图像的空域卷积。\n",
    "# keras.layers.convolutional.Conv2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, \n",
    "#                                  dilation_rate=(1, 1), activation=None, use_bias=True, kernel_initializer='glorot_uniform', \n",
    "#                                  bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, \n",
    "#                                  activity_regularizer=None, kernel_constraint=None, bias_constraint=None)\n",
    "# filters：卷积核的数目（即输出的维度）\n",
    "# kernel_size：卷积核的宽度和长度。如为单个整数，则表示在各个空间维度的相同长度。\n",
    "# strides：卷积的步长。如为单个整数，则表示在各个空间维度的相同步长。\n",
    "# activation：激活函数，如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）\n",
    "# padding：补0策略，为“valid”, “same” 。\n",
    "# use_bias:布尔值，是否使用偏置项\n",
    "# kernel_initializer：权值初始化方法\n",
    "# bias_initializer：权值初始化方法\n",
    "# kernel_regularizer：施加在权重上的正则项\n",
    "# bias_regularizer：施加在偏置向量上的正则项\n",
    "# activity_regularizer：施加在输出上的正则项\n",
    "# kernel_constraints：施加在权重上的约束项\n",
    "# bias_constraints：施加在偏置上的约束项\n",
    "\n",
    "# 卷积层1\n",
    "net = Conv2D(32, kernel_size=[5,5], strides=[1,1], activation='selu', padding='same',\n",
    "             kernel_initializer = 'glorot_normal',  # Glorot正态分布初始化方法，也称作Xavier正态分布初始化\n",
    "             bias_initializer = initializers.Constant(value=0.01), \n",
    "             input_shape=[28,28,1])(x_image)  \n",
    "# 第一层卷积必须显示指定input_shape输入数据形状[高，宽，通道数]\n",
    "# Conv2D 是类方法，第一层时需传递输入数据x_image\n",
    "\n",
    "\n",
    "# 最大值池化层\n",
    "# keras.layers.pooling.MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None)\n",
    "# pool_size：代表在两个方向（竖直，水平）上的下采样因子，如取（2，2）将使图片在两个维度上均变为原长的一半。\n",
    "# strides：步长值\n",
    "# border_mode：‘valid’或者‘same’\n",
    "# data_format：“channels_first”或“channels_last”之一，代表图像的通道维的位置。以128x128的RGB图像为例，\n",
    "#              “channels_first”应将数据组织为（3,128,128），而“channels_last”应将数据组织为（128,128,3）。\n",
    "\n",
    "# 池化层1\n",
    "net = MaxPooling2D(pool_size=[2,2])(net) # 池化\n",
    "\n",
    "#卷积层2\n",
    "net = Conv2D(64, kernel_size=[5,5], strides=[1,1],activation='selu', padding='same', \n",
    "             kernel_initializer = 'glorot_normal',  # Glorot正态分布初始化方法，也称作Xavier正态分布初始化\n",
    "             bias_initializer = initializers.Constant(value=0.01))(net)\n",
    "\n",
    "# 池化层2\n",
    "net = MaxPooling2D(pool_size=[2,2])(net)\n",
    "\n",
    "# Flatten层，用来将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。Flatten不影响batch的大小。\n",
    "net = Flatten()(net) \n",
    "\n",
    "# Dropout层\n",
    "net = Dropout(0.7)(net)\n",
    "\n",
    "# 全连接层\n",
    "# keras.layers.core.Dense(units, activation=None, use_bias=True, kernel_initializer='glorot_uniform', \n",
    "#                         bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, \n",
    "#                         activity_regularizer=None, kernel_constraint=None, bias_constraint=None)\n",
    "# units：大于0的整数，代表该层的输出维度\n",
    "# activation：激活函数，如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）\n",
    "# use_bias: 布尔值，是否使用偏置项\n",
    "# kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器\n",
    "# bias_initializer：偏置向量初始化方法，为预定义初始化方法名的字符串，或用于初始化偏置向量的初始化器\n",
    "# kernel_regularizer：施加在权重上的正则项\n",
    "# bias_regularizer：施加在偏置向量上的正则项\n",
    "# activity_regularizer：施加在输出上的正则项\n",
    "# kernel_constraints：施加在权重上的约束项\n",
    "# bias_constraints：施加在偏置上的约束项\n",
    "\n",
    "# 全连接层1\n",
    "net = Dense(1000, activation='selu')(net) # 全连接层\n",
    "\n",
    "# 全连接层2\n",
    "net = Dense(10,activation='softmax')(net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算交叉熵\n",
    "from keras.objectives import categorical_crossentropy\n",
    "cross_entropy = tf.reduce_mean(categorical_crossentropy(y_, net)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "l2_loss = tf.add_n( [tf.nn.l2_loss(w) for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)] )\n",
    "#惩罚因子，即正则化因子\n",
    "regularization_rate = 1e-4\n",
    "total_loss = cross_entropy + regularization_rate * l2_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(total_loss)\n",
    "sess = tf.Session()\n",
    "K.set_session(sess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 100, entropy loss: 0.177918, l2_loss: 793.167053, total loss: 0.257234, lr: 0.100000, accuracy: 0.990000\n",
      "step 200, entropy loss: 0.245442, l2_loss: 793.626892, total loss: 0.324805, lr: 0.100000, accuracy: 0.990000\n",
      "step 300, entropy loss: 0.072500, l2_loss: 793.373047, total loss: 0.151837, lr: 0.100000, accuracy: 0.980000\n",
      "step 400, entropy loss: 0.131339, l2_loss: 792.922729, total loss: 0.210631, lr: 0.100000, accuracy: 1.000000\n",
      "step 500, entropy loss: 0.116027, l2_loss: 792.308838, total loss: 0.195258, lr: 0.100000, accuracy: 1.000000\n",
      "step 500, 训练正确率:  0.976673\n",
      "step 500, 测试正确率:  0.978500\n",
      "step 600, entropy loss: 0.049450, l2_loss: 791.680298, total loss: 0.128619, lr: 0.100000, accuracy: 1.000000\n",
      "step 700, entropy loss: 0.070440, l2_loss: 791.075562, total loss: 0.149548, lr: 0.100000, accuracy: 1.000000\n",
      "step 800, entropy loss: 0.047360, l2_loss: 790.225830, total loss: 0.126382, lr: 0.100000, accuracy: 1.000000\n",
      "step 900, entropy loss: 0.086276, l2_loss: 789.370728, total loss: 0.165213, lr: 0.100000, accuracy: 0.990000\n",
      "step 1000, entropy loss: 0.073179, l2_loss: 788.365845, total loss: 0.152015, lr: 0.100000, accuracy: 1.000000\n",
      "step 1000, 训练正确率:  0.984473\n",
      "step 1000, 测试正确率:  0.982100\n",
      "step 1100, entropy loss: 0.011343, l2_loss: 787.488647, total loss: 0.090092, lr: 0.100000, accuracy: 1.000000\n",
      "step 1200, entropy loss: 0.006686, l2_loss: 786.514648, total loss: 0.085338, lr: 0.100000, accuracy: 1.000000\n",
      "step 1300, entropy loss: 0.053305, l2_loss: 785.550293, total loss: 0.131860, lr: 0.100000, accuracy: 1.000000\n",
      "step 1400, entropy loss: 0.013604, l2_loss: 784.554077, total loss: 0.092060, lr: 0.100000, accuracy: 1.000000\n",
      "step 1500, entropy loss: 0.013421, l2_loss: 783.595825, total loss: 0.091780, lr: 0.100000, accuracy: 1.000000\n",
      "step 1500, 训练正确率:  0.987582\n",
      "step 1500, 测试正确率:  0.984700\n",
      "step 1600, entropy loss: 0.046944, l2_loss: 782.529785, total loss: 0.125197, lr: 0.100000, accuracy: 1.000000\n",
      "step 1700, entropy loss: 0.038694, l2_loss: 781.565979, total loss: 0.116851, lr: 0.100000, accuracy: 1.000000\n",
      "step 1800, entropy loss: 0.035671, l2_loss: 780.596008, total loss: 0.113731, lr: 0.100000, accuracy: 1.000000\n",
      "step 1900, entropy loss: 0.014183, l2_loss: 779.601196, total loss: 0.092144, lr: 0.100000, accuracy: 1.000000\n",
      "step 2000, entropy loss: 0.010691, l2_loss: 778.655273, total loss: 0.088557, lr: 0.100000, accuracy: 1.000000\n",
      "step 2000, 训练正确率:  0.991018\n",
      "step 2000, 测试正确率:  0.987300\n",
      "step 2100, entropy loss: 0.068917, l2_loss: 777.696655, total loss: 0.146687, lr: 0.100000, accuracy: 1.000000\n",
      "step 2200, entropy loss: 0.005373, l2_loss: 776.611755, total loss: 0.083034, lr: 0.100000, accuracy: 1.000000\n",
      "step 2300, entropy loss: 0.012098, l2_loss: 775.552185, total loss: 0.089654, lr: 0.100000, accuracy: 1.000000\n",
      "step 2400, entropy loss: 0.004190, l2_loss: 774.543701, total loss: 0.081645, lr: 0.100000, accuracy: 1.000000\n",
      "step 2500, entropy loss: 0.009556, l2_loss: 773.423401, total loss: 0.086898, lr: 0.100000, accuracy: 1.000000\n",
      "step 2500, 训练正确率:  0.992782\n",
      "step 2500, 测试正确率:  0.987900\n",
      "step 2600, entropy loss: 0.020880, l2_loss: 772.394531, total loss: 0.098119, lr: 0.100000, accuracy: 1.000000\n",
      "step 2700, entropy loss: 0.016412, l2_loss: 771.312073, total loss: 0.093543, lr: 0.100000, accuracy: 1.000000\n",
      "step 2800, entropy loss: 0.051884, l2_loss: 770.223450, total loss: 0.128906, lr: 0.100000, accuracy: 1.000000\n",
      "step 2900, entropy loss: 0.018080, l2_loss: 769.128418, total loss: 0.094993, lr: 0.100000, accuracy: 1.000000\n",
      "step 3000, entropy loss: 0.028509, l2_loss: 768.100342, total loss: 0.105319, lr: 0.100000, accuracy: 1.000000\n",
      "step 3000, 训练正确率:  0.993182\n",
      "step 3000, 测试正确率:  0.988300\n",
      "step 3100, entropy loss: 0.057968, l2_loss: 767.095947, total loss: 0.134677, lr: 0.100000, accuracy: 1.000000\n",
      "step 3200, entropy loss: 0.021978, l2_loss: 765.990967, total loss: 0.098577, lr: 0.100000, accuracy: 1.000000\n",
      "step 3300, entropy loss: 0.019284, l2_loss: 764.969177, total loss: 0.095781, lr: 0.100000, accuracy: 1.000000\n",
      "step 3400, entropy loss: 0.002852, l2_loss: 763.893738, total loss: 0.079241, lr: 0.100000, accuracy: 1.000000\n",
      "step 3500, entropy loss: 0.026305, l2_loss: 762.796509, total loss: 0.102585, lr: 0.100000, accuracy: 1.000000\n",
      "step 3500, 训练正确率:  0.994109\n",
      "step 3500, 测试正确率:  0.989000\n",
      "step 3600, entropy loss: 0.005958, l2_loss: 761.743591, total loss: 0.082133, lr: 0.100000, accuracy: 1.000000\n",
      "step 3700, entropy loss: 0.008562, l2_loss: 760.687317, total loss: 0.084631, lr: 0.100000, accuracy: 1.000000\n",
      "step 3800, entropy loss: 0.023090, l2_loss: 759.649902, total loss: 0.099055, lr: 0.100000, accuracy: 1.000000\n",
      "step 3900, entropy loss: 0.030569, l2_loss: 758.559998, total loss: 0.106425, lr: 0.100000, accuracy: 1.000000\n",
      "step 4000, entropy loss: 0.009408, l2_loss: 757.445190, total loss: 0.085152, lr: 0.100000, accuracy: 1.000000\n",
      "step 4000, 训练正确率:  0.996182\n",
      "step 4000, 测试正确率:  0.989500\n",
      "step 4100, entropy loss: 0.013953, l2_loss: 756.319031, total loss: 0.089585, lr: 0.100000, accuracy: 1.000000\n",
      "step 4200, entropy loss: 0.006383, l2_loss: 755.161682, total loss: 0.081900, lr: 0.100000, accuracy: 1.000000\n",
      "step 4300, entropy loss: 0.002415, l2_loss: 754.051270, total loss: 0.077820, lr: 0.100000, accuracy: 1.000000\n",
      "step 4400, entropy loss: 0.007818, l2_loss: 752.903137, total loss: 0.083109, lr: 0.100000, accuracy: 1.000000\n",
      "step 4500, entropy loss: 0.049358, l2_loss: 751.719360, total loss: 0.124530, lr: 0.100000, accuracy: 1.000000\n",
      "step 4500, 训练正确率:  0.997327\n",
      "step 4500, 测试正确率:  0.989600\n",
      "step 4600, entropy loss: 0.011783, l2_loss: 750.623657, total loss: 0.086845, lr: 0.100000, accuracy: 1.000000\n",
      "step 4700, entropy loss: 0.084929, l2_loss: 749.423096, total loss: 0.159871, lr: 0.100000, accuracy: 0.990000\n",
      "step 4800, entropy loss: 0.004005, l2_loss: 748.277588, total loss: 0.078833, lr: 0.100000, accuracy: 1.000000\n",
      "step 4900, entropy loss: 0.010508, l2_loss: 747.145203, total loss: 0.085223, lr: 0.100000, accuracy: 1.000000\n",
      "step 5000, entropy loss: 0.004827, l2_loss: 746.074585, total loss: 0.079435, lr: 0.087000, accuracy: 1.000000\n",
      "step 5000, 训练正确率:  0.997927\n",
      "step 5000, 测试正确率:  0.990600\n",
      "step 5100, entropy loss: 0.001109, l2_loss: 745.025757, total loss: 0.075611, lr: 0.087000, accuracy: 1.000000\n",
      "step 5200, entropy loss: 0.013672, l2_loss: 743.950745, total loss: 0.088067, lr: 0.087000, accuracy: 1.000000\n",
      "step 5300, entropy loss: 0.003469, l2_loss: 742.926697, total loss: 0.077762, lr: 0.087000, accuracy: 1.000000\n",
      "step 5400, entropy loss: 0.012224, l2_loss: 741.933167, total loss: 0.086417, lr: 0.087000, accuracy: 1.000000\n",
      "step 5500, entropy loss: 0.002200, l2_loss: 740.918457, total loss: 0.076292, lr: 0.075690, accuracy: 1.000000\n",
      "step 5500, 训练正确率:  0.998564\n",
      "step 5500, 测试正确率:  0.990300\n",
      "step 5600, entropy loss: 0.005870, l2_loss: 739.984009, total loss: 0.079868, lr: 0.075690, accuracy: 1.000000\n",
      "step 5700, entropy loss: 0.015615, l2_loss: 739.051392, total loss: 0.089520, lr: 0.075690, accuracy: 1.000000\n",
      "step 5800, entropy loss: 0.005373, l2_loss: 738.141907, total loss: 0.079188, lr: 0.075690, accuracy: 1.000000\n",
      "step 5900, entropy loss: 0.000635, l2_loss: 737.221497, total loss: 0.074357, lr: 0.075690, accuracy: 1.000000\n",
      "step 6000, entropy loss: 0.024064, l2_loss: 736.286926, total loss: 0.097692, lr: 0.065850, accuracy: 1.000000\n",
      "step 6000, 训练正确率:  0.998691\n",
      "step 6000, 测试正确率:  0.989400\n",
      "step 6100, entropy loss: 0.001245, l2_loss: 735.479004, total loss: 0.074792, lr: 0.065850, accuracy: 1.000000\n",
      "step 6200, entropy loss: 0.000573, l2_loss: 734.657288, total loss: 0.074039, lr: 0.065850, accuracy: 1.000000\n",
      "step 6300, entropy loss: 0.000464, l2_loss: 733.851135, total loss: 0.073849, lr: 0.065850, accuracy: 1.000000\n",
      "step 6400, entropy loss: 0.000851, l2_loss: 733.051758, total loss: 0.074156, lr: 0.065850, accuracy: 1.000000\n",
      "step 6500, entropy loss: 0.001790, l2_loss: 732.225342, total loss: 0.075012, lr: 0.057290, accuracy: 1.000000\n",
      "step 6500, 训练正确率:  0.999764\n",
      "step 6500, 测试正确率:  0.990800\n",
      "step 6600, entropy loss: 0.003484, l2_loss: 731.500671, total loss: 0.076634, lr: 0.057290, accuracy: 1.000000\n",
      "step 6700, entropy loss: 0.003719, l2_loss: 730.792419, total loss: 0.076798, lr: 0.057290, accuracy: 1.000000\n",
      "step 6800, entropy loss: 0.000875, l2_loss: 730.055359, total loss: 0.073881, lr: 0.057290, accuracy: 1.000000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 6900, entropy loss: 0.001554, l2_loss: 729.341980, total loss: 0.074488, lr: 0.057290, accuracy: 1.000000\n",
      "step 7000, entropy loss: 0.003339, l2_loss: 728.623047, total loss: 0.076201, lr: 0.049842, accuracy: 1.000000\n",
      "step 7000, 训练正确率:  0.999509\n",
      "step 7000, 测试正确率:  0.990600\n",
      "step 7100, entropy loss: 0.001509, l2_loss: 727.989563, total loss: 0.074308, lr: 0.049842, accuracy: 1.000000\n",
      "step 7200, entropy loss: 0.005464, l2_loss: 727.366516, total loss: 0.078200, lr: 0.049842, accuracy: 1.000000\n",
      "step 7300, entropy loss: 0.001141, l2_loss: 726.734070, total loss: 0.073815, lr: 0.049842, accuracy: 1.000000\n",
      "step 7400, entropy loss: 0.004913, l2_loss: 726.107178, total loss: 0.077524, lr: 0.049842, accuracy: 1.000000\n",
      "step 7500, entropy loss: 0.014596, l2_loss: 725.480652, total loss: 0.087145, lr: 0.043363, accuracy: 1.000000\n",
      "step 7500, 训练正确率:  0.999800\n",
      "step 7500, 测试正确率:  0.991600\n",
      "step 7600, entropy loss: 0.000143, l2_loss: 724.929993, total loss: 0.072636, lr: 0.043363, accuracy: 1.000000\n",
      "step 7700, entropy loss: 0.003507, l2_loss: 724.386780, total loss: 0.075946, lr: 0.043363, accuracy: 1.000000\n",
      "step 7800, entropy loss: 0.000675, l2_loss: 723.843567, total loss: 0.073059, lr: 0.043363, accuracy: 1.000000\n",
      "step 7900, entropy loss: 0.002873, l2_loss: 723.287720, total loss: 0.075202, lr: 0.043363, accuracy: 1.000000\n",
      "step 8000, entropy loss: 0.000907, l2_loss: 722.746704, total loss: 0.073182, lr: 0.037725, accuracy: 1.000000\n",
      "step 8000, 训练正确率:  0.999764\n",
      "step 8000, 测试正确率:  0.991700\n"
     ]
    }
   ],
   "source": [
    "init_op = tf.global_variables_initializer()\n",
    "sess.run(init_op)\n",
    "batch_size = 100\n",
    "# 学习速率\n",
    "lr = 0.10\n",
    "# 学习速率的衰减率\n",
    "lr_decay = 0.87\n",
    "acc_train_mat = []\n",
    "acc_test_mat = []\n",
    "loss_mat = []\n",
    "l2_loss_mat = []\n",
    "total_loss_mat = []\n",
    "# 训练\n",
    "for step in range(8000):   \n",
    "    # 当训练集loss出现波动或趋于平稳，开始学习速率衰减\n",
    "    if (step+1) >= 5000 and (step+1) % 500 == 0:\n",
    "        # 衰减学习速率\n",
    "        lr *= lr_decay\n",
    "        \n",
    "    batch_xs, batch_ys = mnist.train.next_batch(batch_size)\n",
    "    _, loss, l2_loss_value, total_loss_value = sess.run(\n",
    "               [train_step, cross_entropy, l2_loss, total_loss], \n",
    "               feed_dict={x: batch_xs, y_: batch_ys, learning_rate:lr})\n",
    "    if (step+1) % 100 == 0: \n",
    "        # 测试模型\n",
    "        correct_prediction = tf.equal(tf.argmax(net, 1), tf.argmax(y_, 1))\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "        print('step %d, entropy loss: %f, l2_loss: %f, total loss: %f, lr: %f, accuracy: %f' % \n",
    "                (step+1, loss, l2_loss_value, total_loss_value, lr, sess.run(accuracy, feed_dict={x: batch_xs, y_: batch_ys})))\n",
    "        loss_mat.append(loss)\n",
    "        l2_loss_mat.append(l2_loss_value)\n",
    "        total_loss_mat.append(total_loss_value)\n",
    "        \n",
    "        if (step+1) % 500 == 0:\n",
    "            batch_size_pre = 1000\n",
    "            # 计算训练误差，因显卡内存不足，故分批计算求平均值\n",
    "            train_size = mnist.train.images.shape\n",
    "            acc_batch = 0\n",
    "            acc = []\n",
    "            step_time = (int)(train_size[0]/batch_size_pre)\n",
    "            for step_train in range(step_time):\n",
    "                batch_xs, batch_ys = mnist.train.next_batch(batch_size_pre)\n",
    "                acc_batch = sess.run(accuracy, feed_dict={x: batch_xs, y_: batch_ys})\n",
    "                acc.append(acc_batch)\n",
    "            step_acc_train = np.mean(acc)\n",
    "            print('step %d, 训练正确率:  %f' % (step+1, step_acc_train))\n",
    "            acc_train_mat.append(step_acc_train)\n",
    "\n",
    "            # 计算测试误差，因显卡内存不足，故分批计算求平均值\n",
    "            test_size = mnist.test.images.shape\n",
    "            acc_batch = 0\n",
    "            acc = []\n",
    "            step_time = (int)(test_size[0]/batch_size_pre)\n",
    "            for step_test in range(step_time):\n",
    "                batch_xs_test, batch_ys_test = mnist.test.next_batch(batch_size_pre)\n",
    "                acc_batch = sess.run(accuracy, feed_dict={x: batch_xs_test, y_: batch_ys_test})\n",
    "                acc.append(acc_batch)\n",
    "            step_acc_test = np.mean(acc)\n",
    "            print('step %d, 测试正确率:  %f' % (step+1, step_acc_test))\n",
    "            acc_test_mat.append(step_acc_test)\n",
    "            \n",
    "            if step_acc_test >= 0.993:\n",
    "                break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAEKCAYAAADn+anLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xd4VHXa//H3nULoPdJCl6oIQujNsioogqIo9o4FbLvr7rq6PrvPs66uZVcRRVHEDoq9gLK6KL0EFEEpUgQCCKFGert/f8zJz4gEEsnMmSSf13XNlZnvnDP5QCa555zzLebuiIiIHE5C2AFERCR+qUiIiEieVCRERCRPKhIiIpInFQkREcmTioSIiORJRUJERPKkIiEiInlSkRARkTwlhR3gWFWvXt0bNGgQdgwRkSJlzpw5G9099WjbFfki0aBBAzIyMsKOISJSpJjZyvxsp9NNIiKSJxUJERHJk4qEiIjkSUVCRETypCIhIiJ5UpEQEZE8qUiIiEieivw4icKwa+8BPl+8gcwtu2haswItalXguAqlw44lIhK6Elskdu09wMTFG/ho/jr+u3ADu/Yd+Nnz1cuXom29KvRuVZPTW9SgYunkkJKKiISnxBaJ56eu4OFPFlO9fCn6t63DOa1q0axmBZas387Cddl8uy6bKd9tZMK360lONLodX53+bdPofWJNkhJ1lk5ESgZz97AzHJP09HT/NdNy/LBtN8uzttOhYdU8/+gfPOh8lbmV8fPXMW7+D6zZuos6lctwVZf6XNy+HpXK6OhCRIomM5vj7ulH3a6kFomCOnjQ+WzRBkZOWc6M5ZspVyqRi9vX49puDUirUjbq319EpDCpSETRgjXbGDllBR/MW4sD57SqxaAejTixTqWY5hAR+bVUJGJg7dZdjJq6gtGzVrN9z346NarKtV0bcnqLGiQmWCiZRETyQ0UihrJ372PMrFW8OG0la7buol7VslzdpQGXdapHSlJiqNlERA4nv0Uiqt10zKyZmX2V65ZtZneYWWszm25m883sAzOrmGufu81sqZktNrOzopmvsFQsncygHo354q5TGH5ZW2pUTOF/P/yW3o9NZtrSjWHHExH51WJ2JGFmicAaoCPwJvB7d//CzK4FGrr7X8ysJTAa6ADUBj4Fmrr7gbxeNx6OJA7niyVZ3PfeAlZu2sl5bWpzzzktSa2QEnYsEREgTo4kDnE6sMzdVwLNgElB+3+AC4L7/YAx7r7H3VcAS4kUjCKnZ9NUPrmjB7eddjzj5v/AaY9+zsszVnLwYNE+vSciJUssi8RAIkcJAAuAvsH9AUDd4H4dYHWufTKDtp8xs0FmlmFmGVlZWVGKe+xKJyfy2zObMf6O7rSqU4m/vLuA/sOn8c3abWFHExHJl5gUCTMrRaQojA2argUGm9kcoAKwN2fTw+z+i4/e7j7C3dPdPT019ajreIeucWp5Xr2+I/++uDWrN++k77CpPDBuIXv253kWTUQkLsTqSKI3MNfd1wO4+yJ3P9Pd2xE5ulgWbJfJT0cVAGnA2hhljCoz4/yT0/jsdz0Z0C6NZyYtp/9T01ietT3saCIieYpVkbiEn041YWbHBV8TgHuBp4On3gcGmlmKmTUEmgCzYpQxJiqXLcWDF5zEs1ems2brLvo8MYWxGasp6l2RRaR4inqRMLOywBnA27maLzGzJcAiIkcKowDc/RvgDeBb4GNg8JF6NhVlZ7Sswce39+CktErc9ebXDHntS7J+3BN2LBGRn9FgupAdOOg8/cUyHv/0O0onJ3DPOS24KL0uZhqxLSLRE49dYOUwEhOMwacez/g7utO8VkX++NZ8Bo6YwYqNO8KOJiKiIhEvGqeWZ8wNnXiwfysWrsvm7Mcn89rMVbpWISKhUpGIIwkJxsAO9ZhwZ0/a1q/Mn9+Zzw0vzWHTdl2rEJFwqEjEoZqVSvPytR2595wWTFqSxVmPTWbi4g1hxxKREkhFIk4lJBjXd2/Ee0O6Uq1cKa4ZNZt7353Prr3FsrOXiMQpFYk416JWRd4b0pXruzXklRmrOGfoZOat3hp2LBEpIVQkioDSyYnc26clr13fkd37DtB/+DSG/fc7DmiyQBGJMhWJIqTL8dUZf0cPep9Yk0cmLOGy52awbtuusGOJSDGmIlHEVCqTzBOXnMzDF57E15nb6PXYZD5e8EPYsUSkmFKRKILMjAHpdfnotu7Uq1qWm16Zwx/enMf2PfvDjiYixYyKRBHWsHo53rq5C7ec0pg352TS+/FJzP5+c9ixRKQYUZEo4kolJfCHXs1548bOGMZFz0znwfGL2HfgYNjRRKQYUJEoJtIbVGXc7d25OL0uT3+xjMuencmG7N1hxxKRIk5Fohgpn5LEgxecxOMD2zB/zTbOHjqFGcs3hR1LRIowFYliqF+bOrw3pCsVyyRx2XMzeerzpRpTISK/iopEMdW0RgXeH9KNXifW5KGPF3PpszPI3LIz7FgiUsSoSBRj5VOSGBaMqfhmbTa9H5vM23MzNf24iOSbikQxlzOmYvzt3WleqwK/fWMeQ177kq0794YdTUSKABWJEqJu1bKMGdSZP/ZqzoRvf+CsxyYx5buNYccSkTgX1SJhZs3M7Ktct2wzu8PM2pjZjKAtw8w6BNubmQ01s6Vm9rWZtY1mvpImMcG4+ZTGvHNLVyqUTubykTP53w++Zfc+TT8uIocX1SLh7ovdvY27twHaATuBd4CHgL8F7fcFjwF6A02C2yBgeDTzlVQn1qnEh7d246rO9Xl+6grOe3IqS9b/GHYsEYlDsTzddDqwzN1XAg5UDNorAWuD+/2AlzxiBlDZzGrFMGOJUTo5kb/1O5FR17Rn4/Y9nPvEFF6esVIXtUXkZ2JZJAYCo4P7dwAPm9lq4BHg7qC9DrA61z6ZQdvPmNmg4DRVRlZWVhQjF3+nNjuO8bf3oFOjavzl3QXc8NIcNu/QRW0RiYhJkTCzUkBfYGzQdDNwp7vXBe4ERuZsepjdf/HR1t1HuHu6u6enpqZGI3KJklohhVFXt+cvfVoyaUkWZ/57Ep9+uz7sWCISB2J1JNEbmOvuOX95rgLeDu6PBToE9zOBurn2S+OnU1ESRQkJxnXdGvL+rV1JrZDC9S9lcNfYefy4e1/Y0UQkRLEqEpfw06kmiPzh7xncPw34Lrj/PnBl0MupE7DN3dfFKKMAzWtW5L3BXRl8amPemptJr8cmM32Z5n8SKamiXiTMrCxwBj8dOQDcADxqZvOAfxDpyQQwDlgOLAWeBW6Jdj75pVJJCdx1VnPevLkLpZISuPS5Gdz/kbrKipREVtR7s6Snp3tGRkbYMYqtnXv3849xC3llxiqa1ajAvy5uzQm1K4UdS0SOkZnNcff0o22nEddyRGVLJfH381ox6pr2bN65l/OenMor6iorUmKoSEi+nNrsOCbc0YMujatz77sLuOvNr3X6SaQEUJGQfKtSrhTPX92e2047njfnZHLh09NYvVnTj4sUZyoSUiCJCcZvz2zGc1ems3LTTs4dNoWJizaEHUtEokRFQn6V37SswQdDulGzYmmueWE2j05YrNXvRIohFQn51RpUL8e7g7syoF0aT/x3KVc+P5ON2/eEHUtECpGKhByT0smJPDygNQ9dcBIZ32/h7McnM22Z1qkQKS5UJKRQXNS+Lu/c0pXypZO47LmZPPLJYvYfOBh2LBE5RioSUmha1q7Ih7d2Y0C7NIZNXMpFz0wnc4t6P4kUZSoSUqjKlkrioQtb8/jANixZv51zn5ii008iRZiKhERFvzZ1+ODWblQrn8IVI2fxwtQVGqUtUgSpSEjUNKxejndu6cKpzY7jrx98yx/f+po9+zVKW6QoUZGQqKpQOpkRV7TjttOO542MTC4cPp2Vm3aEHUtE8klFQqIuIRil/cwV7Vi5aQd9hk7ho6+1TIhIUaAiITFz1gk1+ei27jQ+rjyDX5vLve/O1ySBInFORUJiqm7Vsoy9qTODejTilRmrGPC0usmKxDMVCYm55MQE/nx2C0Zc0Y7vN+7g3CemMPm7rLBjichhqEhIaM48oSbvDelKaoUUrnp+Fk9OXMpBTRIoEleiWiTMrJmZfZXrlm1md5jZ67navjezr3Ltc7eZLTWzxWZ2VjTzSfgapZbn3cFdOeek2jz8yWJuemUOP+7eF3YsEQkkRfPF3X0x0AbAzBKBNcA77v5YzjZm9iiwLbjfEhgInADUBj41s6burqubxVjZUkkMHdiGNnUr849xC+k3bCrPXNGOJjUqhB1NpMSL5emm04Fl7r4yp8HMDLgIGB009QPGuPsed18BLAU6xDCjhMTMuK5bQ169viPZu/fR78mpjJuvbrIiYYtlkRjIT8UgR3dgvbt/FzyuA6zO9Xxm0CYlRKdG1fjw1u40q1mBW16dywPjF2oxI5EQxaRImFkpoC8w9pCnLuHnhcMOs/sv/kKY2SAzyzCzjKws9YopbmpWKs2YQZ24rGM9nvliOVc9P4stO/aGHUukRIrVkURvYK67r89pMLMkoD/weq7tMoG6uR6nAWsPfTF3H+Hu6e6enpqaGqXIEqaUpETuP78VD11wErNWbKbPE1NYsGZb2LFESpxYFYlDjxgAfgMscvfMXG3vAwPNLMXMGgJNgFkxyihx6KL2dRl7U2cOutN/+DRenblSs8mKxFC+i4SZ3W5mFS1ipJnNNbMz87FfWeAM4O1DnvrFNQp3/wZ4A/gW+BgYrJ5N0rpuZT64tRudGlXjnncWcOvoL9VNViRGLL+fysxsnru3DsYuDAb+Aoxy97bRDHg06enpnpGREWYEiZGDB52nJy3j0QlLSKtShmGXtKVVWqWwY4kUSWY2x93Tj7ZdQU435VxUPptIcZjH4S80i0RFQoJxyynH8/qgTuzdf5D+w6fy3OTlGqUtEkUFKRJzzGwCkSLxiZlVALTSvcRceoOqjL+9O6c2O46/f7SQa1+czcbte8KOJVIsFaRIXAf8CWjv7juBZOCaqKQSOYrKZUvxzBXt+L9+JzBt2SZ6PTaZqUu1lrZIYStIkegMLHb3rWZ2OXAvwXQaImEwM67o3ID3h3Slctlkrhg5kxGTlqn3k0ghKkiRGA7sNLPWwB+AlcBLUUklUgDNa1bk3cFdOeuEmvxj3CJuH/MVu/aqU5xIYShIkdjvkY9o/YDH3f1xQDOwSVwon5LEU5e15a6zmvHB12vpP3waqzZpMSORY1WQIvGjmd0NXAF8FMzqmhydWCIFZ2YMPvV4Rl3dnjVbdnLO0MlaS1vkGBWkSFwM7AGudfcfiEy893BUUokcg1OaHfeztbTveUdraYv8WvkuEkFheBWoZGZ9gN3urmsSEpdy1tK+sWcjXp25ivOenMqyrO1hxxIpcgoyLcdFROZRGkBkDYiZZnZhtIKJHKvkxATu7t2CUde0Z8OPe+g3bCofL9DpJ5GCKMjppnuIjJG4yt2vJLIY0F+iE0uk8Jza7Dg+vLUbjY8rz02vzOWBcQvZf0DjQEXyoyBFIsHdN+R6vKmA+4uEpnblMrxxYycu71SPZyYt5/KRMzVKWyQfCvJH/mMz+8TMrjazq4GPgHHRiSVS+FKSEvn7ea14dEBrvly1lXOfmMK81VvDjiUS1wpy4fouYARwEtAaGOHuf4xWMJFouaBdGm/d3IUEMwY8M503Zq8++k4iJVS+pwqPV5oqXH6tzTv2ctvoL5mydCOXdqzH/5zbkpSkxLBjicREoU0VbmY/mln2YW4/mll24cQVib2q5UrxwjXtubFnI16buYoBT09n9WaN0hbJ7ahFwt0ruHvFw9wquHvFnO3MrEp0o4oUvqSgm+wzV7RjxcYd9HliCp8tXH/0HUVKiMLsnfRZIb6WSEyddUJNPry1G2lVynDdixk8OH6RusmKULhFQqvUSZFWv1o53rq5C5d2rMfTXyzj0udmsiF7d9ixREJVmEXiF1fAzayZmX2V65ZtZncEz91qZovN7BszeyjXPneb2dLgubMKMZ/IUZVOTuQf57fi3xe3Zn7mNs4eOoVpy7SYkZRcUR0M5+6L3b2Nu7cB2gE7gXfM7FQiU46f5O4nAI8AmFlLYCBwAtALeCqYbVYkps4/OY33hnSlUpkkLn9uJk9OXKq1tKVEiuXpptOBZe6+ErgZeNDd9wDkGsndDxjj7nvcfQWwlMj0HyIx17RGBd4f0o0+J9Xm4U8Wc/ULs9mkUdpSwhRmkTj9KM8PBEYH95sC3c1sppl9YWbtg/Y6QO6RTZlBm0goyqUk8fjANtx//onMWL6Js4dOZtaKzWHHEomZ/IyTaGVmM8xstZmNyN3V1cxm5dx39zx/c8ysFNAXGBs0JQFVgE7AXcAbZmYc/mjkcNc6BplZhpllZGVlHe2fIHJMzIzLOtbnnVu6UCY5kUuencHTX2gtbSkZ8nMkMRz4K9AKWAJMMbPGwXP5XZmuNzDX3XM6oGcCb3vELOAgUD1or5trvzRg7aEv5u4j3D3d3dNTU1PzGUHk2JxQuxIf3NqNXifW5MHxi7jl1bls37M/7FgiUZWfIlHe3T92963u/ggwhMhkf504zKf8PFzCT6eaAN4FTgMws6ZAKWAj8D4w0MxSzKwh0ITIGhYicaFC6WSGXXIy95zdggnfrtdiRlLs5adImJlVynng7hOBC4CXgfr52LkscAbwdq7m54FGZrYAGANcFRxVfAO8AXwLfAwMdnetOylxxcy4oUcjXr6uA1t27KXfsKlM+OaHsGOJRMVRJ/gzs0uB5e4+45D2esBf3P2GKOY7Kk3wJ2Fau3UXN70yh68zt3HHb5pw22lNSEjQuFKJf4U2wZ+7v3ZogQjaV4VdIETCFlnMqDP929bhsU+/46ZX5ug6hRQrSUfbwMw+4AjXHty9b6EmEiliSicn8uiA1pxYuxL3j1vI+U9O5dkr02lQvVzY0USO2VGLBMFoaBHJm5lxbbeGNK9ZgcGvzaXfk1MZdunJdG+i3ndStBXaokNm9pa7X1AoL1YAuiYh8Wb15p3c8FIGS9b/yJ/PbsF13RoSGQYkEj8K7ZpEATQqxNcSKbLqVi3LWzd34YyWNfj7Rwv5/div2bNfnfSkaIrqLLAiJVW5lCSGX9aO209vwltzM7n02Zls1LxPUgRFdRZYkZIsIcG484ymPHlpW75Zu41+w6ay6Aet+CtFixYdEomyc06qxRs3dmbfgYNc8NQ0LY8qRcqvKhJmVsXMTjqk+Y+FkEekWDoprTLvD+lGw9RyXP9SBk99vlQTBEqRkO8iYWafm1lFM6sKzANGmdm/cp539wnRCChSXNSsVJqxN3ahz0m1eejjxQx57Ut2aOCdxLmCHElUcvdsoD8wyt3bAb+JTiyR4qlMqUSGDmzD3b2bM37BOi4YPo1Vm3aGHUskTwUpEklmVgu4CPgwSnlEij0z48aejXnhmg6s27abvk9qHW2JXwUpEv8LfEJkCdLZZtYI+C46sUSKvx5NU3l/SFeql0/hypGzeHXmyrAjifxCoY24DotGXEtRl717H7eN/pLPF2dxdZcG3HtOC5IS1TtdoqvQR1ybWSMz+8DMssxsg5m9FywMJCLHoGLpZEZe1Z7ruzXkhWnfc+2LGWTv3hd2LBGgYKebXiOyIFAtoDaR9arHRCOUSEmTmGDc26cl/7ygFdOWbmTA8OlkbtEFbQlfQYqEufvL7r4/uL2CpuIQKVQXt6/Hi9d2YO22XZz35DTmrd4adiQp4QpSJCaa2Z/MrIGZ1TezPwAfmVnVYOyEiBSCrsdX5+2bu1A6OYGLR0xn3Px1YUeSEizfF67NbMURnnZ3D2UWWF24luJq4/Y9DHopg7mrtnLzKY35/ZnNSNTSqFJI8nvhOj+LDgHg7gW+SG1mzYDXczU1Au4DKgM3AFlB+5/dfVywz93AdcAB4DZ3/6Sg31ekOKhePoXRgzrxtw++Zfjny1iwZhtDB55MlXKlwo4mJUhBejeVNbN7zWxE8LiJmfU50j7uvtjd27h7G6AdsBN4J3j63znP5SoQLYGBwAlAL+ApM0ss+D9LpHhISUrkH+e34sH+rZi5fDPnDpvCwnWaSVZipyDXJEYBe4EuweNM4O8F2P90IgPxjjRiqB8wxt33uPsKYCnQoQDfQ6RYGtihHm/c1Jn9B5wBT0/niyVZR99JpBAUpEg0dveHgH0A7r6Lgk0PPhAYnevxEDP72syeN7MqQVsdYHWubTKDNpESr03dyrwzuAtpVcpw7QuzeX32qrAjSQlQkCKx18zKEHR7NbPGQL6W2jKzUkBfImMrAIYDjYE2wDrg0ZxND7P7L66sm9kgM8sws4ysLH2ikpKjVqUyjL2pM12Pr84f35rPI58s1pTjElUFKRJ/BT4G6prZq8Bn5H8Nid7AXHdfD+Du6939gLsfBJ7lp1NKmUDdXPulAWsPfTF3H+Hu6e6enpqaWoB/gkjRV6F0MiOvSmdg+7oMm7iUIaO/ZNderaEt0VGQ3k0TzGwO0InIJ/7b3T2/U1deQq5TTWZWy91zOn+fDywI7r8PvBasU1EbaALMym9GkZIiOTGBB/q3omH1cjz48SJWbtrBs1emU6tSmbCjSTFTkN5Nn7n7Jnf/yN0/dPeNZvZZPvYrC5wBvJ2r+SEzm29mXwOnAncCuPs3RKb++JbIUctgd9dHJJHDyJly/Lkr0/l+4076DpvKl6u2hB1LipmjDqYzs9JAWWAicAo/XTeoCIx39xbRDHg0GkwnAkvW/8h1L85mffYe/nlBK84/OS3sSBLnCnMW2BuBOUDz4OscIAN4Dxh2LCFFpHA0rVGB9wZ3o229ytz5+jweGL+QAwd1QVuO3VGLhLs/Hoy2vh9oE9wfBSwHpkc5n4jkU9VypXj5uo5c3qkez3yxnOtfnK0px+WYFaR304Xunm1m3YhcY3iBSFdWEYkTyYkJ/P28VvzfeScy+buNnPfkVJZu+DHsWFKEFaRI5FxAPgd42t3fAzSJjEgcuqJTfV6+riPZu/bRd9hUPvz6Fz3JRfKlIEVijZk9A1wEjDOzlALuLyIx1LlxNT68tTstalVkyGtf8rcPvmHfgYNhx5IipiB/5C8CPgF6uftWoCpwV1RSiUihqFmpNGMGdeLarg0ZNfV7Bo6Ywbptu8KOJUVIvouEu+9097fd/bvg8Tp3nxC9aCJSGJITE7jv3JYMu/RkFq3L5pyhU5ikCQIln3S6SKSE6HNSbd6/tRvHVUjhqlGz+NeExeomK0elIiFSgjROLc87t3TlwrZpDP3vUq4YOZON2/M1T6eUUCoSIiVMmVKJPDygNQ9deBJzVm6hz9ApzNV0HpIHFQmREuqi9Lq8dXMXkpOMi5+ZzsvTv9e04/ILKhIiJdiJdSrx4ZDudDu+On957xvueP0rtu/ZH3YsiSMqEiIlXKWyyYy8qj2/P7MpH8xby7lPTGHBmm1hx5I4oSIhIiQkGENOa8LoGzqxa+8B+j81jZem6/STqEiISC4dG1Vj3O3d6dakOve99w03vjyHLTv2hh1LQqQiISI/U7VcKZ67Mp17z2nBxMUb6PX4JKYtze8ilFLcqEiIyC8kJBjXd2/EO7d0pVxKEpeNnMmD4xdp7qcSSEVCRPJ0Yp1KfHhrNwa2r8fTXyxjwNPTWb15Z9ixJIZUJETkiMqWSuKB/q146rK2LMvaztmPT+ajr9eFHUtiJKpFwsyamdlXuW7ZZnZHrud/b2ZuZtWDx2ZmQ81sqZl9bWZto5lPRPLv7Fa1GHdbdxofV57Br83l7re/ZofGVBR7US0S7r7Y3du4exugHbATeAfAzOoSWeFuVa5degNNgtsgtPKdSFypW7UsY2/qzE09GzNm9mp6Pz6ZWSs2hx1LoiiWp5tOB5a5+8rg8b+BPwC5O2L3A17yiBlAZTOrFcOMInIUyYkJ/Kl3c8bc0AmAi0dM5+8ffsvufQeOsqcURbEsEgOB0QBm1hdY4+7zDtmmDrA61+PMoE1E4kzHRtUYf3t3Lu9Yn+emrODsoZP5UhMFFjsxKRJmVgroC4w1s7LAPcB9h9v0MG2/GPJpZoPMLMPMMrKytHiKSFjKpSTxf+edyCvXdWT33gNcMHwa//x4EXv266iiuIjVkURvYK67rwcaAw2BeWb2PZAGzDWzmkSOHOrm2i8N+MUK7u4+wt3T3T09NTU16uFF5Mi6NanOx3f24MJ2aQz/fBl9n5iq+Z+KiVgViUsITjW5+3x3P87dG7h7AyKFoa27/wC8D1wZ9HLqBGxzd/W1EykCKpZO5qELW/P81els2bmXfk9O5ZFPFuuoooiLepEITi+dAbydj83HAcuBpcCzwC1RjCYiUXBa8xr8586enNemDsMmLqXP0Cm6VlGEWVGf5TE9Pd0zMjLCjiEihzFx8Qb+/PZ81mfv5vrujfjtGU0pnZwYdiwBzGyOu6cfbTuNuBaRqDm12XFMuLMHF7evx4hJyzl76GQtlVrEqEiISFRVKJ3MA/1b8cp1Hdmz7yAXDp/GP8Yt1LiKIkJFQkRioluT6nx8R/f/f1RxztDJfLV6a9ix5ChUJEQkZnKOKl6+rgM79x6g/1NTefgTjauIZyoSIhJz3Zuk8smdPbigbRpPTlxGv2FT1QMqTqlIiEgoKpZO5uEBrRl5VWRcxflPTeN3b8xjw4+7w44muahIiEioTm9Rg89+dwo3n9KY9+et4bRHvuCZL5axd79WwYsHKhIiErryKUn8sVdzJtzZk44Nq/LA+EX0enwSk7/T3GxhU5EQkbjRsHo5Rl7dnuevTufAQeeKkbO4+ZU5rNm6K+xoJVZS2AFERA51WvMadGlcnecmL2fYxKVMXLyBm3sez409G2nEdozpSEJE4lLp5ESGnNaET3/bk9Ob1+Dfny7h9Ee/YPz8dRT16YSKEhUJEYlraVXK8uRlbRl9QycqlE7i5lfncumzM1m4LjvsaCWCioSIFAmdG1fjw1u78X/9TmDhD9mcM3Qyf3l3AVt27A07WrGmIiEiRUZSYgJXdG7A578/hSs7N+C1Was45ZHPeWHqCvYfUJfZaFCREJEip3LZUvy17wmMv707repU4q8ffEufJ6Yw+/vNYUcrdlQkRKTIalqjAi9f14Hhl7Ule9c+Bjw9nd+BSc7lAAAMqklEQVS+/hUbsjVqu7CoC6yIFGlmRu9WtejZLJUnJy7l2UkrGL/gB67p2oAbezSmUtnksCMWaVqZTkSKlZWbdvCv/yzh/XlrKZ+SxE09G3N1lwaUS9Fn4tzyuzKdioSIFEsL12Xz6IQlfLpwPdXKleLmUxpzeaf6GowXiIsiYWbNgNdzNTUC7gOqAf2Ag8AG4Gp3X2tmBjwOnA3sDNrnHul7qEiIyJHMXbWFf01YwpSlGzmuQgqDTz2egR3qkpJUsotFXBSJn30js0RgDdAR2OLu2UH7bUBLd7/JzM4GbiVSJDoCj7t7xyO9roqEiOTHjOWb+NeEJcz6fjNpVcrwuzOb0rd1HRITLOxoochvkYhl76bTgWXuvjKnQATKATmVqh/wkkfMACqbWa0YZhSRYqpTo2q8fmMnXry2A5XKJHPn6/M4Z+hk/rtovab5OIJYFomBwOicB2Z2v5mtBi4jcgoKoA6wOtc+mUGbiMgxMzN6Nk3lgyHdGHrJyezad4BrX8jgwqenM23ZxrDjxaWYFAkzKwX0BcbmtLn7Pe5eF3gVGJKz6WF2/0WJN7NBZpZhZhlZWZpvXkQKJiHB6Nu6Np/+tif3n38ia7bs4tJnZ3LJiBnMWakBebnF6kiiNzDX3dcf5rnXgAuC+5lA3VzPpQFrD93B3Ue4e7q7p6emphZ6WBEpGZITE7isY30+v+sU7uvTku82/MgFw6dzzahZLFizLex4cSFWReISfn6qqUmu5/oCi4L77wNXWkQnYJu7r4tRRhEpoUonJ3Jtt4ZM+sOp/LFXc+au2kqfJ6Yw+NW5LN3wY9jxQhX13k1mVpbIdYZG7r4taHsLaEakC+xK4CZ3XxN0gR0G9CLSBfYadz9i1yX1bhKRwrZt1z5GTl7OyCkr2LnvAGe0qMGNPRvRrn7VsKMVmrjrAhstKhIiEi2btu/hxWnf89KMlWzduY/0+lUY1KMRv2lRg4Qi3nVWRUJEpJDs3LufN2av5rkpK8jcsouG1ctxXbeGXNA2jTKliuagPBUJEZFCtv/AQT7+5geenbSceZnbqFI2mSs6N+CqzvWpVj4l7HgFoiIhIhIl7s7s77cwYtJyPl24npSkBC5sl8YN3RvRoHq5sOPlS36LhKZFFBEpIDOjQ8OqdGhYlaUbtvPc5OWMzcjktVmrOKtlTW7o0Yh29auEHbNQ6EhCRKQQbMjezQvTvueVGSvJ3r2f9PpVuCG4yB2P80PpdJOISAh27NnPGxmrGXnIRe4L26XF1TTlKhIiIiE69CJ31XKluLxTfS7tUI+alUqHHU9FQkQkHrg7s1Zs5tnJy/l04QYSDE5rXoNLO9alZ9PjQjsVpQvXIiJxwMzo2KgaHRtVY+WmHYyZvZqxGav5dOF6alUqzYD0ulzcvi51KpcJO+ph6UhCRCTG9u4/yGcL1zN69momfxeZybpHk1Qu6VCX01vUIDkx+tPq6XSTiEgRsHrzTsZmrOaNjEx+yN5N9fKluKBdGgPb16NhFMdcqEiIiBQhBw46XyzZwOhZq/nvog0cOOh0alSVSzvW56wTahT6mtwqEiIiRdSG7N2MnZPJmNmrWL15F1XLlWJAuzQGdii8owsVCRGRIu7gQWfy0o28NnMlny786ehiYPt69Dqx5jGNu1CREBEpRtZn7+bNOZm8Pns1qzbvpGLpJO479wQubJf2q15PXWBFRIqRGhVLM/jU47m5Z2NmrNjE67NXU7ty9AflqUiIiBQhCQlGl8bV6dK4emy+X0y+i4iIFEkqEiIikqeoFgkza2ZmX+W6ZZvZHWb2sJktMrOvzewdM6uca5+7zWypmS02s7OimU9ERI4sqkXC3Re7ext3bwO0A3YC7wD/AU5095OAJcDdAGbWEhgInAD0Ap4ys/iZW1dEpISJ5emm04Fl7r7S3Se4+/6gfQaQ04erHzDG3fe4+wpgKdAhhhlFRCSXWBaJgcDow7RfC4wP7tcBVud6LjNoExGREMSkSJhZKaAvMPaQ9nuA/cCrOU2H2f0Xo/3MbJCZZZhZRlZWVmHHFRGRQKyOJHoDc919fU6DmV0F9AEu85+GfWcCdXPtlwasPfTF3H2Eu6e7e3pqamoUY4uIlGwxmZbDzMYAn7j7qOBxL+BfQE93z8q13QnAa0SuQ9QGPgOauPuBI7x2FrDyV0arDmz8lftGW7xmi9dcEL/Z4jUXxG+2eM0FxSdbfXc/6qfsqBcJMytL5DpDI3ffFrQtBVKATcFmM9z9puC5e4hcp9gP3OHu43/5qoWWLSM/c5eEIV6zxWsuiN9s8ZoL4jdbvOaCkpct6tNyuPtOoNohbccfYfv7gfujnUtERI5OI65FRCRPJb1IjAg7wBHEa7Z4zQXxmy1ec0H8ZovXXFDCshX59SRERCR6SvqRhIiIHEGJLRJm1iuYRHCpmf0p5CzPm9kGM1uQq62qmf3HzL4LvlYJIVddM5toZgvN7Bszuz0esplZaTObZWbzglx/C9obmtnMINfrwSDOUJhZopl9aWYfxks2M/vezOYHk21mBG2hv8+CHJXN7M1g4s+FZtY5HrIdYZLSeMh2Z/D+X2Bmo4Pfi0J/n5XIIhFMGvgkkUF+LYFLgskFw/ICkQkNc/sT8Jm7NyEyXiSMQrYf+J27twA6AYOD/6ews+0BTnP31kAboJeZdQL+Cfw7yLUFuC7GuXK7HViY63G8ZDs1mHQzp5tk2D/LHI8DH7t7c6A1kf+70LMdYZLSULOZWR3gNiDd3U8EEolMfVT47zN3L3E3oDORwX05j+8G7g45UwNgQa7Hi4Fawf1awOI4+H97DzgjnrIBZYG5QEcig4iSDvczjnGmNCJ/OE4DPiQy3Uzo2YDvgeqHtIX+swQqAisIrpHGU7ZD8pwJTI2HbPw0z11VIkMZPgTOisb7rEQeSVA0JhKs4e7rAIKvx4UZxswaACcDM4mDbMHpnK+ADUSmnl8GbPWfZhcO82f6GPAH4GDwuBrxkc2BCWY2x8wGBW2h/yyBRkAWMCo4RfecmZWLk2y55Z6kNNRs7r4GeARYBawDtgFziML7rKQWiXxNJCgRZlYeeIvICPjssPMAuPsBj5wCSCMyjUuLw20W21RgZn2ADe4+J3fzYTYN4/3W1d3bEjnNOtjMeoSQ4XCSgLbAcHc/GdhBeKe9DiuvSUrDElwD6Qc0JDKFUTkiP9dDHfP7rKQWiXxNJBiy9WZWCyD4uiGMEGaWTKRAvOrub8dTNgB33wp8TuSaSWUzy5lFIKyfaVegr5l9D4whcsrpsXjI5u5rg68biJxX70B8/CwzgUx3nxk8fpNI0YiHbDkOnaQ07Gy/AVa4e5a77wPeBroQhfdZSS0Ss4EmQU+AUkQOI98POdOh3geuCu5fReR6QEyZmQEjgYXu/q94yWZmqRYseWtmZYj8wiwEJgIXhpULwN3vdvc0d29A5H31X3e/LOxsZlbOzCrk3Cdyfn0BcfA+c/cfgNVm1ixoOh34Nh6y5XIJP18PJ+xsq4BOZlY2+D3N+T8r/PdZmBeCwrwBZxNZOnUZcE/IWUYTOa+4j8inquuInMf+DPgu+Fo1hFzdiByufg18FdzODjsbcBLwZZBrAXBf0N4ImEVkRcOxQErIP9dTgA/jIVvw/ecFt29y3vNh/yxz5WsDZAQ/03eBKnGUrSyRyUgr5WoLPRvwN2BR8DvwMpFJUwv9faYR1yIikqeSerpJRETyQUVCRETypCIhIiJ5UpEQEZE8qUiIiEieVCREjkEwI2jZsHOIRIu6wIocg2Bkdbq7bww7i0g06EhCJJ+CUcsfBetYLDCz/yEyb85EM5sYbHOmmU03s7lmNjaY9ypnLYd/ButgzDKz44P2AcFrzTOzSeH960QOT0VCJP96AWvdvbVH5vB/jMjcOKe6+6lmVh24F/iNRybSywB+m2v/bHfvAAwL9gW4DzjLI2tj9I3VP0Qkv1QkRPJvPvCb4Iigu7tvO+T5TkQWsZoaTGN+FVA/1/Ojc33tHNyfCrxgZjcQWThGJK4kHX0TEQFw9yVm1o7I/FUPmNmEQzYx4D/ufkleL3HofXe/ycw6AucAX5lZG3ffVNjZRX4tHUmI5JOZ1QZ2uvsrRBZ8aQv8CFQINpkBdM11vaGsmTXN9RIX5/o6PdimsbvPdPf7iKwqlnsKe5HQ6UhCJP9aAQ+b2UEiM/beTOS00XgzWxdcl7gaGG1mKcE+9xKZbRggxcxmEvlwlnO08bCZNSFyFPIZkVlaReKGusCKxIC6ykpRpdNNIiKSJx1JiIhInnQkISIieVKREBGRPKlIiIhInlQkREQkTyoSIiKSJxUJERHJ0/8DGID9uZmLSZoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#可视化\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.plot(range(len(loss_mat)), loss_mat) \n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('steps_entropy_loss')\n",
    "plt.show() \n",
    "\n",
    "plt.plot(range(len(l2_loss_mat)), l2_loss_mat) \n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('steps_l2_loss')\n",
    "plt.show()\n",
    "\n",
    "plt.plot(range(len(total_loss_mat)), total_loss_mat) \n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('steps_total_loss')\n",
    "plt.show()\n",
    "\n",
    "plt.plot(range(len(acc_train_mat)), acc_train_mat, label='Train Accuracy') \n",
    "plt.plot(range(len(acc_test_mat)), acc_test_mat, label='Test Accuracy')\n",
    "plt.legend()\n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('accuracy')\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "毫无疑问，这个模型是一个非常简陋，性能也不理想的模型。目前只能达到92%左右的准确率。\n",
    "接下来，希望大家利用现有的知识，将这个模型优化至98%以上的准确率。\n",
    "Hint：\n",
    "- 卷积\n",
    "- 池化\n",
    "- 激活函数\n",
    "- 正则化\n",
    "- 初始化\n",
    "- 摸索一下各个超参数\n",
    "  - 卷积kernel size\n",
    "  - 卷积kernel 数量\n",
    "  - 学习率\n",
    "  - 正则化惩罚因子\n",
    "  - 最好每隔几个step就对loss、accuracy等等进行一次输出，这样才能有根据地进行调整"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
